home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / tlhelp32.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  6.2 KB  |  188 lines
  1. /*****************************************************************************\
  2. *                                                                             *
  3. * tlhelp32.h -    WIN32 tool help functions, types, and definitions          *
  4. *                                                                             *
  5. * Version 1.0                                      *
  6. *                                                                             *
  7. * NOTE: windows.h/winbase.h must be #included first                  *
  8. *                                                                             *
  9. * Copyright (c) 1994-1995, Microsoft Corp.   All rights reserved.           *
  10. *                                                                             *
  11. \*****************************************************************************/
  12.  
  13. /*
  14.  *      C/C++ Run Time Library - Version 9.0
  15.  *
  16.  *      Copyright (c) 1997, 1998 by Borland International
  17.  *      All Rights Reserved.
  18.  *
  19.  */
  20.  
  21. #ifndef _INC_TOOLHELP32
  22. #define _INC_TOOLHELP32
  23. #pragma option push -b
  24.  
  25.  
  26. #ifdef __BORLANDC__
  27. #  include <pshpack8.h>
  28. #endif
  29.  
  30. #ifdef __cplusplus
  31. extern "C" {            /* Assume C declarations for C++ */
  32. #endif    /* __cplusplus */
  33.  
  34. #define MAX_MODULE_NAME32 255
  35.  
  36. /****** Shapshot function **********************************************/
  37.  
  38. HANDLE WINAPI CreateToolhelp32Snapshot(DWORD dwFlags, DWORD th32ProcessID);
  39. //
  40. // The th32ProcessID argument is only used if TH32CS_SNAPHEAPLIST or
  41. // TH32CS_SNAPMODULE is specified. th32ProcessID == 0 means the current
  42. // process.
  43. //
  44. // NOTE that all of the snapshots are global except for the heap and module
  45. //    lists which are process specific. To enumerate the heap or module
  46. //    state for all WIN32 processes call with TH32CS_SNAPALL and the
  47. //    current process. Then for each process in the TH32CS_SNAPPROCESS
  48. //    list that isn't the current process, do a call with just
  49. //    TH32CS_SNAPHEAPLIST and/or TH32CS_SNAPMODULE.
  50. //
  51. // dwFlags
  52. //
  53. #define TH32CS_SNAPHEAPLIST 0x00000001
  54. #define TH32CS_SNAPPROCESS  0x00000002
  55. #define TH32CS_SNAPTHREAD   0x00000004
  56. #define TH32CS_SNAPMODULE   0x00000008
  57. #define TH32CS_SNAPALL        (TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE)
  58. #define TH32CS_INHERIT        0x80000000
  59. //
  60. // Use CloseHandle to destroy the snapshot
  61. //
  62.  
  63. /****** heap walking ***************************************************/
  64.  
  65. typedef struct tagHEAPLIST32
  66. {
  67.     DWORD  dwSize;
  68.     DWORD  th32ProcessID;   // owning process
  69.     DWORD  th32HeapID;        // heap (in owning process's context!)
  70.     DWORD  dwFlags;
  71. } HEAPLIST32;
  72. typedef HEAPLIST32 *  PHEAPLIST32;
  73. typedef HEAPLIST32 *  LPHEAPLIST32;
  74. //
  75. // dwFlags
  76. //
  77. #define HF32_DEFAULT      1  // process's default heap
  78. #define HF32_SHARED      2  // is shared heap
  79.  
  80. BOOL WINAPI Heap32ListFirst(HANDLE hSnapshot, LPHEAPLIST32 lphl);
  81. BOOL WINAPI Heap32ListNext(HANDLE hSnapshot, LPHEAPLIST32 lphl);
  82.  
  83. typedef struct tagHEAPENTRY32
  84. {
  85.     DWORD  dwSize;
  86.     HANDLE hHandle;    // Handle of this heap block
  87.     DWORD  dwAddress;    // Linear address of start of block
  88.     DWORD  dwBlockSize; // Size of block in bytes
  89.     DWORD  dwFlags;
  90.     DWORD  dwLockCount;
  91.     DWORD  dwResvd;
  92.     DWORD  th32ProcessID;   // owning process
  93.     DWORD  th32HeapID;        // heap block is in
  94. } HEAPENTRY32;
  95. typedef HEAPENTRY32 *  PHEAPENTRY32;
  96. typedef HEAPENTRY32 *  LPHEAPENTRY32;
  97. //
  98. // dwFlags
  99. //
  100. #define LF32_FIXED    0x00000001
  101. #define LF32_FREE     0x00000002
  102. #define LF32_MOVEABLE 0x00000004
  103.  
  104. BOOL WINAPI Heap32First(LPHEAPENTRY32 lphe, DWORD th32ProcessID,
  105.             DWORD th32HeapID);
  106. BOOL WINAPI Heap32Next(LPHEAPENTRY32 lphe);
  107. BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD    th32ProcessID,
  108.                     LPCVOID lpBaseAddress,
  109.                     LPVOID    lpBuffer,
  110.                     DWORD    cbRead,
  111.                     LPDWORD lpNumberOfBytesRead);
  112.  
  113. /***** Process walking *************************************************/
  114.  
  115. typedef struct tagPROCESSENTRY32
  116. {
  117.     DWORD   dwSize;
  118.     DWORD   cntUsage;
  119.     DWORD   th32ProcessID;        // this process
  120.     DWORD   th32DefaultHeapID;
  121.     DWORD   th32ModuleID;        // associated exe
  122.     DWORD   cntThreads;
  123.     DWORD   th32ParentProcessID;    // this process's parent process
  124.     LONG    pcPriClassBase;        // Base priority of process's threads
  125.     DWORD   dwFlags;
  126.     char    szExeFile[MAX_PATH];    // Path
  127. } PROCESSENTRY32;
  128. typedef PROCESSENTRY32 *  PPROCESSENTRY32;
  129. typedef PROCESSENTRY32 *  LPPROCESSENTRY32;
  130.  
  131. BOOL WINAPI Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe);
  132. BOOL WINAPI Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe);
  133.  
  134. /***** Thread walking **************************************************/
  135.  
  136. typedef struct tagTHREADENTRY32
  137. {
  138.     DWORD   dwSize;
  139.     DWORD   cntUsage;
  140.     DWORD   th32ThreadID;    // this thread
  141.     DWORD   th32OwnerProcessID; // Process this thread is associated with
  142.     LONG    tpBasePri;
  143.     LONG    tpDeltaPri;
  144.     DWORD   dwFlags;
  145. } THREADENTRY32;
  146. typedef THREADENTRY32 *  PTHREADENTRY32;
  147. typedef THREADENTRY32 *  LPTHREADENTRY32;
  148.  
  149. BOOL WINAPI Thread32First(HANDLE hSnapshot, LPTHREADENTRY32 lpte);
  150. BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY32 lpte);
  151.  
  152. /***** Module walking *************************************************/
  153.  
  154. typedef struct tagMODULEENTRY32
  155. {
  156.     DWORD   dwSize;
  157.     DWORD   th32ModuleID;    // This module
  158.     DWORD   th32ProcessID;    // owning process
  159.     DWORD   GlblcntUsage;    // Global usage count on the module
  160.     DWORD   ProccntUsage;    // Module usage count in th32ProcessID's context
  161.     BYTE  * modBaseAddr;    // Base address of module in th32ProcessID's context
  162.     DWORD   modBaseSize;    // Size in bytes of module starting at modBaseAddr
  163.     HMODULE hModule;        // The hModule of this module in th32ProcessID's context
  164.     char    szModule[MAX_MODULE_NAME32 + 1];
  165.     char    szExePath[MAX_PATH];
  166. } MODULEENTRY32;
  167. typedef MODULEENTRY32 *  PMODULEENTRY32;
  168. typedef MODULEENTRY32 *  LPMODULEENTRY32;
  169.  
  170. //
  171. // NOTE CAREFULLY that the modBaseAddr and hModule fields are valid ONLY
  172. // in th32ProcessID's process context.
  173. //
  174.  
  175. BOOL WINAPI Module32First(HANDLE hSnapshot, LPMODULEENTRY32 lpme);
  176. BOOL WINAPI Module32Next(HANDLE hSnapshot, LPMODULEENTRY32 lpme);
  177.  
  178. #ifdef __cplusplus
  179. }
  180. #endif
  181.  
  182. #ifdef __BORLANDC__
  183. #  include <poppack.h>
  184. #endif
  185.  
  186. #pragma option pop
  187. #endif // _INC_TOOLHELP32
  188.